LLMs — Grandes Modelos de Linguagem

1 O que são LLMs?

Modelos gigantes treinados em trilhões de tokens — e por que eles impressionam tanto.

Por que "Large"?

A escala é o que torna LLMs especiais. Modelos modernos têm:

O que LLMs fazem bem (e mal)

2 Pré-treinamento — aprendendo a linguagem

A fase onde o modelo "lê" a internet inteira e aprende padrões de linguagem.

Next Token Prediction

# Objetivo do pré-treinamento
# Dado: "O gato dormiu no"
# Prever: "sofá" (probabilidade 0.72)

# O modelo vê:
tokens = ["O", "gato", "dormiu", "no"]

# E prevê distribuição de probabilidades:
probs = {
    "sofá": 0.72,
    "chão": 0.15,
    "telhado": 0.08,
    "colo": 0.03,
    "outro": 0.02
}

# Loss function: cross-entropy
# Penaliza o modelo se o token correto tinha baixa probabilidade

🎮 Simulador: Next Token Prediction

Dados de treinamento

O que o modelo aprende?

3 Fine-tuning — adaptando ao seu domínio

Pós-treinamento supervisionado para tarefas específicas.

Tipos de fine-tuning

Exemplo: fine-tuning para suporte da Nimbus Cloud

# Dataset de fine-tuning
training_data = [
    {
        "input": "Qual o timeout do endpoint /v2/sync?",
        "output": "O timeout padrão do endpoint /v2/sync é 30 segundos. Para arquivos maiores que 500MB, recomendamos aumentar a variável NIMBUS_TIMEOUT para 120 segundos."
    },
    {
        "input": "Como aumentar o timeout?",
        "output": "Para aumentar o timeout, edite o arquivo de configuração config.yaml e adicione: NIMBUS_TIMEOUT: 120. Reinicie o serviço após a alteração."
    },
    # ... milhares de exemplos
]

# Fine-tuning com Hugging Face
from transformers import AutoModelForCausalLM, AutoTokenizer, Trainer

model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3-8b")
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3-8b")

# Configura treinamento
trainer = Trainer(
    model=model,
    train_dataset=training_data,
    args=TrainingArguments(
        output_dir="./nimbus-support-model",
        num_train_epochs=3,
        per_device_train_batch_size=4,
        learning_rate=2e-5
    )
)

# Treina
trainer.train()

# Salva modelo fine-tuned
model.save_pretrained("./nimbus-support-model")

Quando usar fine-tuning vs RAG?

4 RLHF — alinhamento com humanos

Como fazer o modelo seguir instruções e evitar respostas tóxicas.

As 3 etapas do RLHF

1. Coleta de dados: humanos comparam pares de respostas (A vs B) e escolhem a melhor
2. Treino do reward model: um modelo aprende a prever quais respostas humanos preferem
3. Refinamento com PPO: o LLM é ajustado para maximizar a recompensa do reward model

Exemplo: comparando respostas

# Humano compara duas respostas
Pergunta: "Como aumentar o timeout?"

Resposta A: "Edite config.yaml e adicione NIMBUS_TIMEOUT: 120."
Resposta B: "Você pode tentar reiniciar o servidor ou verificar se há problemas de rede."

# Humano escolhe: A é melhor (mais específica e útil)
# Reward model aprende: respostas específicas > respostas vagas

# Após RLHF, o modelo gera mais respostas do tipo A

Por que RLHF é importante?

5 Temperature e Sampling — controlando a geração

Como ajustar a "criatividade" do modelo.

🎮 Simulador: Temperature

A fórmula

# Temperature scaling
probs_adjusted = softmax(logits / temperature)

# Onde:
# logits = scores brutos do modelo (antes de softmax)
# temperature = hiperparâmetro (0.1 a 2.0)

# Exemplo:
logits = [5.0, 3.0, 1.0]  # scores brutos

# Temperature = 0.1 (baixa)
probs_low = [0.88, 0.11, 0.01]  # quase determinístico

# Temperature = 1.0 (normal)
probs_normal = [0.76, 0.20, 0.04]

# Temperature = 2.0 (alta)
probs_high = [0.55, 0.30, 0.15]  # mais aleatório

Outros parâmetros de sampling

Quando usar cada temperature?

6 Context Window — o limite de memória

Quantos tokens o modelo pode processar de uma vez — e por que isso importa.

🎮 Simulador: Context Window

Context windows de modelos populares

Implicações para RAG

7 Modelos populares em 2026

GPT, Claude, Llama, Mistral — qual escolher para seu caso de uso?

Comparador de modelos

Como escolher?

Modelos locais com Ollama

# Instala Ollama (https://ollama.com)
# Baixa e roda modelos localmente

# Lista modelos disponíveis
ollama list

# Baixa Llama 3 8B
ollama pull llama3.1:8b

# Roda interativamente
ollama run llama3.1:8b

# Usa via API
curl http://localhost:11434/api/generate -d '{
  "model": "llama3.1:8b",
  "prompt": "Qual o timeout do endpoint /v2/sync?"
}'

# Modelos recomendados para RAG local:
# - llama3.1:8b (8B parâmetros, 8K context)
# - mistral:7b (7B parâmetros, 32K context)
# - qwen2.5:7b (7B parâmetros, bom em português)

8 Conexão com RAG

Como LLMs se integram ao pipeline RAG.

O pipeline RAG com LLMs

# Pipeline completo

# 1. Usuário faz pergunta
question = "Qual o timeout do endpoint /v2/sync?"

# 2. Busca chunks relevantes (vetorial + BM25)
chunks = vector_db.search(question, top_k=5)

# 3. Monta prompt
prompt = f"""SYSTEM: Responda apenas com base no contexto.

CONTEXTO:
{format_context(chunks)}

PERGUNTA: {question}

RESPOSTA:"""

# 4. Chama LLM
import ollama

response = ollama.generate(
    model="llama3.1:8b",
    prompt=prompt,
    options={
        "temperature": 0.1,  # baixa para precisão
        "top_p": 0.9,
        "num_ctx": 8192  # context window
    }
)

# 5. Retorna resposta
answer = response["response"]
print(answer)
# "O timeout padrão do endpoint /v2/sync é 30 segundos..."

Escolhas críticas no RAG

Otimização de custos

🎯 Quiz — teste seu conhecimento

Clique em uma alternativa para ver se acertou.

→ O que vem a seguir?

Agora que você entende LLMs, vamos aprender a "conversar" com eles de forma eficaz.

Conceitos que vamos construir aqui